package com.example.graphic.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.example.graphic.AI.ImageDescriptionRequest;
import com.example.graphic.AI.ImageDescriptionResponse;
import com.example.graphic.entity.Image;
import com.example.graphic.model.dto.DeleteDTO;
import com.example.graphic.model.dto.ImageQueryDTO;
import com.example.graphic.model.dto.UploadDTO;
import com.example.graphic.model.vo.Result;
import com.example.graphic.service.ImageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.util.Arrays;
import java.util.List;

/**
 * 图片管理控制器
 */
@Slf4j
@RestController
@RequestMapping("/images")
@CrossOrigin(origins = "*")
public class ImageController {

    @Autowired
    private ImageService imageService;

    /**
     * 分页条件查询图片
     *
     * 支持的查询参数：
     * - pageNum: 页码，默认1
     * - pageSize: 每页大小，默认10，最大100
     * - tagIds: 标签ID列表，支持多个标签筛选
     * - contentKeyword: 文案关键词，支持模糊搜索
     * - fileNameKeyword: 文件名关键词，支持模糊搜索
     * - sortBy: 排序方式，time(按时间倒序) 或 frequency(按访问频率倒序)，默认time
     *
     * @param queryDTO 查询参数
     * @return 分页结果，包含图片列表及关联的标签和文案数据
     */
    @PostMapping("/page")
    public Result<IPage<Image>> pageQuery(@RequestBody ImageQueryDTO queryDTO) {
        try {
            // 参数校验
            if (queryDTO == null) {
                queryDTO = new ImageQueryDTO();
            }

            // 页码校验
            if (queryDTO.getPageNum() != null && queryDTO.getPageNum() < 1) {
                return Result.error(400, "页码必须大于0");
            }

            // 页大小校验
            if (queryDTO.getPageSize() != null && (queryDTO.getPageSize() < 1 || queryDTO.getPageSize() > 100)) {
                return Result.error(400, "每页大小必须在1-100之间");
            }

            // 排序参数校验
            if (queryDTO.getSortBy() != null &&
                    !queryDTO.getSortBy().equals("time") &&
                    !queryDTO.getSortBy().equals("frequency")) {
                return Result.error(400, "排序参数只能是time或frequency");
            }

            // 标签ID列表校验
            if (!CollectionUtils.isEmpty(queryDTO.getTagIds())) {
                boolean hasInvalidTagId = queryDTO.getTagIds().stream()
                        .anyMatch(tagId -> tagId == null || tagId <= 0);
                if (hasInvalidTagId) {
                    return Result.error(400, "标签ID必须为正整数");
                }
            }

            // 关键词长度校验
            if (queryDTO.getContentKeyword() != null && queryDTO.getContentKeyword().length() > 100) {
                return Result.error(400, "文案关键词长度不能超过100个字符");
            }
            if (queryDTO.getFileNameKeyword() != null && queryDTO.getFileNameKeyword().length() > 50) {
                return Result.error(400, "文件名关键词长度不能超过50个字符");
            }

            // 执行查询
            IPage<Image> result = imageService.pageQuery(queryDTO);

            return Result.success(result);

        } catch (IllegalArgumentException e) {
            return Result.error(400, "参数错误: " + e.getMessage());
        } catch (Exception e) {
            // 记录错误日志
            System.err.println("图片分页查询失败: " + e.getMessage());
            e.printStackTrace();

            return Result.error("查询失败，请稍后重试");
        }
    }

    /**
     * 批量上传图片
     *
     * @param files 图片文件数组
     * @return 上传结果，包含文件URL列表
     */
    @PostMapping("/upload")
    public Result<List<String>> uploadImages(@RequestParam("files") MultipartFile[] files,@RequestParam("user_id") String userId) {
        try {
            // 参数校验
            if (files == null || files.length == 0) {
                return Result.error(400, "请选择要上传的图片文件");
            }
            Long userIdLong;
            // 参数校验
            if (userId == null) {
                return Result.error(400, "User_id 不能为空");
            }else{
                userIdLong  = Long.parseLong(userId);
            }

            // 文件数量限制
            if (files.length > 10) {
                return Result.error(400, "单次最多只能上传10张图片");
            }

            // 转换为List调用服务
            List<MultipartFile> fileList = Arrays.asList(files);

            // 调用服务层上传图片
            List<String> uploadUrls = imageService.uploadImages(fileList,userIdLong);

            if (uploadUrls.isEmpty()) {
                return Result.error("没有有效的图片文件被上传");
            }

            log.info("成功上传 {} 张图片", uploadUrls.size());
            return Result.success(uploadUrls);

        } catch (IllegalArgumentException e) {
            log.warn("图片上传参数错误: {}", e.getMessage());
            return Result.error(400, "参数错误: " + e.getMessage());
        } catch (Exception e) {
            log.error("图片上传失败", e);
            return Result.error("图片上传失败，请稍后重试");
        }
    }

    /**
     * 为图片生成文案
     *
     * @param request 图片生成文案请求参数
     * @return 生成的文案文本
     */
    @PostMapping("/generateCopywriting")
    public Result<ImageDescriptionResponse> generateCopywriting(@RequestBody ImageDescriptionRequest request) {
        log.info("请求："+request+"请求体");
        try {
            // 参数校验
            if (request == null) {
                return Result.error(400, "请求参数不能为空");
            }

            if (request.getImageUrl() == null || request.getImageUrl().trim().isEmpty()) {
                return Result.error(400, "图片URL不能为空");
            }
            if (request.getStyle() == null || request.getStyle().trim().isEmpty()) {
                return Result.error(400, "文案风格不能为空");
            }
            if (request.getTag() == null || request.getTag().trim().isEmpty()) {
                return Result.error(400, "图片标签不能为空");
            }
            if (request.getPrompt() == null || request.getPrompt().trim().isEmpty()) {
                return Result.error(400, "场景提示词不能为空");
            }

            // URL格式校验
            if (!request.getImageUrl().startsWith("http://") && !request.getImageUrl().startsWith("https://")) {
                return Result.error(400, "图片URL格式不正确，必须以http://或https://开头");
            }

            // 风格参数校验
            List<String> validStyles = Arrays.asList("促销型", "温情型", "生活型", "权威型", "价值型", "专业型");
            if (!validStyles.contains(request.getStyle())) {
                return Result.error(400, "文案风格必须是以下之一: " + String.join(", ", validStyles));
            }

            // 长度校验
            if (request.getTag().length() > 100) {
                return Result.error(400, "图片标签长度不能超过100个字符");
            }
            if (request.getPrompt().length() > 500) {
                return Result.error(400, "场景提示词长度不能超过500个字符");
            }

            // 调用服务层生成文案
            ImageDescriptionResponse response = imageService.generateCopywritingResponse(
                request.getImageUrl(),
                request.getStyle(),
                request.getTag(),
                request.getPrompt(),
                request.getUserId()
            );

            if (response == null || !response.isSuccess()) {
                return Result.error("文案生成失败，请稍后重试");
            }

            log.info("用户 {} 为图片 {} 生成文案成功",
                request.getUserId(), request.getImageUrl());

            // 直接返回与API相同格式的响应
            return Result.success(response);

        } catch (IllegalArgumentException e) {
            log.warn("文案生成参数错误: {}", e.getMessage());
            return Result.error(400, "参数错误: " + e.getMessage());
        } catch (Exception e) {
            log.error("文案生成失败", e);
            return Result.error("文案生成失败，请稍后重试");
        }
    }


    @PostMapping("/uploadUrl")
    public Result uploadUrl(@RequestBody UploadDTO uploadDTO) {
        // 调用服务方法上传文件
        return imageService.uploadUrl(uploadDTO.getUserId(), uploadDTO.getUrls());
    }

    /**
     * 删除图片
     *
     * @param deleteDTO 图片ID
     * @return 删除结果
     */
    @DeleteMapping("/delete")
    public Result deleteImage(@RequestBody DeleteDTO deleteDTO) {

        log.info("接收到删除图片请求，图片ID: {}", deleteDTO.getImageId());

        Result response = imageService.deleteImage(deleteDTO.getImageId());

        return response;
    }

}